package sudroid.java.util;

import java.io.Serializable;
import java.lang.reflect.Array;
import java.util.AbstractList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.RandomAccess;
import java.util.Set;

public class Arrays
{
  private static final int INSERTIONSORT_THRESHOLD = 7;

  public static <T> List<T> asList(T[] paramArrayOfT)
  {
    return new ArrayList();
  }

  public static int binarySearch(byte[] paramArrayOfByte, byte paramByte)
  {
    int i = paramArrayOfByte.length;
    return binarySearch0(paramArrayOfByte, 0, i, paramByte);
  }

  public static int binarySearch(byte[] paramArrayOfByte, int paramInt1, int paramInt2, byte paramByte)
  {
    rangeCheck(paramArrayOfByte.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfByte, paramInt1, paramInt2, paramByte);
  }

  public static int binarySearch(char[] paramArrayOfChar, char paramChar)
  {
    int i = paramArrayOfChar.length;
    return binarySearch0(paramArrayOfChar, 0, i, paramChar);
  }

  public static int binarySearch(char[] paramArrayOfChar, int paramInt1, int paramInt2, char paramChar)
  {
    rangeCheck(paramArrayOfChar.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfChar, paramInt1, paramInt2, paramChar);
  }

  public static int binarySearch(double[] paramArrayOfDouble, double paramDouble)
  {
    int i = paramArrayOfDouble.length;
    return binarySearch0(paramArrayOfDouble, 0, i, paramDouble);
  }

  public static int binarySearch(double[] paramArrayOfDouble, int paramInt1, int paramInt2, double paramDouble)
  {
    rangeCheck(paramArrayOfDouble.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfDouble, paramInt1, paramInt2, paramDouble);
  }

  public static int binarySearch(float[] paramArrayOfFloat, float paramFloat)
  {
    int i = paramArrayOfFloat.length;
    return binarySearch0(paramArrayOfFloat, 0, i, paramFloat);
  }

  public static int binarySearch(float[] paramArrayOfFloat, int paramInt1, int paramInt2, float paramFloat)
  {
    rangeCheck(paramArrayOfFloat.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfFloat, paramInt1, paramInt2, paramFloat);
  }

  public static int binarySearch(int[] paramArrayOfInt, int paramInt)
  {
    int i = paramArrayOfInt.length;
    return binarySearch0(paramArrayOfInt, 0, i, paramInt);
  }

  public static int binarySearch(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    rangeCheck(paramArrayOfInt.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfInt, paramInt1, paramInt2, paramInt3);
  }

  public static int binarySearch(long[] paramArrayOfLong, int paramInt1, int paramInt2, long paramLong)
  {
    rangeCheck(paramArrayOfLong.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfLong, paramInt1, paramInt2, paramLong);
  }

  public static int binarySearch(long[] paramArrayOfLong, long paramLong)
  {
    int i = paramArrayOfLong.length;
    return binarySearch0(paramArrayOfLong, 0, i, paramLong);
  }

  public static int binarySearch(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Object paramObject)
  {
    rangeCheck(paramArrayOfObject.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfObject, paramInt1, paramInt2, paramObject);
  }

  public static <T> int binarySearch(T[] paramArrayOfT, int paramInt1, int paramInt2, T paramT, Comparator<? super T> paramComparator)
  {
    rangeCheck(paramArrayOfT.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfT, paramInt1, paramInt2, paramT, paramComparator);
  }

  public static int binarySearch(Object[] paramArrayOfObject, Object paramObject)
  {
    int i = paramArrayOfObject.length;
    return binarySearch0(paramArrayOfObject, 0, i, paramObject);
  }

  public static <T> int binarySearch(T[] paramArrayOfT, T paramT, Comparator<? super T> paramComparator)
  {
    int i = paramArrayOfT.length;
    return binarySearch0(paramArrayOfT, 0, i, paramT, paramComparator);
  }

  public static int binarySearch(short[] paramArrayOfShort, int paramInt1, int paramInt2, short paramShort)
  {
    rangeCheck(paramArrayOfShort.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfShort, paramInt1, paramInt2, paramShort);
  }

  public static int binarySearch(short[] paramArrayOfShort, short paramShort)
  {
    int i = paramArrayOfShort.length;
    return binarySearch0(paramArrayOfShort, 0, i, paramShort);
  }

  private static int binarySearch0(byte[] paramArrayOfByte, int paramInt1, int paramInt2, byte paramByte)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      byte b = paramArrayOfByte[m];
      if (b < paramByte)
      {
        i = m + 1;
        break;
      }
      if (b <= paramByte)
        continue;
      j = m - 1;
      break;
    }
  }

  private static int binarySearch0(char[] paramArrayOfChar, int paramInt1, int paramInt2, char paramChar)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      char c = paramArrayOfChar[m];
      if (c < paramChar)
      {
        i = m + 1;
        break;
      }
      if (c <= paramChar)
        continue;
      j = m - 1;
      break;
    }
  }

  private static int binarySearch0(double[] paramArrayOfDouble, int paramInt1, int paramInt2, double paramDouble)
  {
    int i = paramInt1;
    paramInt2 -= 1;
    int j = i;
    if (j > paramInt2);
    double[] arrayOfDouble;
    for (paramArrayOfDouble = -(j + 1); ; paramArrayOfDouble = arrayOfDouble)
    {
      return paramArrayOfDouble;
      arrayOfDouble = j + paramInt2 >>> 1;
      long l1 = paramArrayOfDouble[arrayOfDouble];
      if (l1 < paramDouble);
      for (paramInt1 = -1; ; paramInt1 = 1)
      {
        if (paramInt1 >= 0)
          break label119;
        j = arrayOfDouble + 1;
        break;
        if (l1 <= paramDouble)
          break label74;
      }
      label74: long l2 = Double.doubleToLongBits(l1);
      l1 = Double.doubleToLongBits(paramDouble);
      if (l2 == l1)
        paramInt1 = 0;
      while (true)
      {
        break;
        if (l2 < l1)
        {
          paramInt1 = -1;
          continue;
        }
        paramInt1 = 1;
      }
      label119: if (paramInt1 <= 0)
        continue;
      paramInt2 = arrayOfDouble - 1;
      break;
    }
  }

  private static int binarySearch0(float[] paramArrayOfFloat, int paramInt1, int paramInt2, float paramFloat)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      int n = paramArrayOfFloat[m];
      if (n < paramFloat);
      for (int i1 = -1; ; i1 = 1)
      {
        if (i1 >= 0)
          break label124;
        i = m + 1;
        break;
        if (n <= paramFloat)
          break label78;
      }
      label78: int i2 = Float.floatToIntBits(n);
      int i3 = Float.floatToIntBits(paramFloat);
      if (i2 == i3)
        i1 = 0;
      while (true)
      {
        break;
        if (i2 < i3)
        {
          i1 = -1;
          continue;
        }
        i1 = 1;
      }
      label124: if (i1 <= 0)
        continue;
      j = m - 1;
      break;
    }
  }

  private static int binarySearch0(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      int n = paramArrayOfInt[m];
      if (n < paramInt3)
      {
        i = m + 1;
        break;
      }
      if (n <= paramInt3)
        continue;
      j = m - 1;
      break;
    }
  }

  private static int binarySearch0(long[] paramArrayOfLong, int paramInt1, int paramInt2, long paramLong)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      long l = paramArrayOfLong[m];
      if (l < paramLong)
      {
        i = m + 1;
        break;
      }
      if (l <= paramLong)
        continue;
      j = m - 1;
      break;
    }
  }

  private static int binarySearch0(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Object paramObject)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      int n = ((Comparable)paramArrayOfObject[m]).compareTo(paramObject);
      if (n < 0)
      {
        i = m + 1;
        break;
      }
      if (n <= 0)
        continue;
      j = m - 1;
      break;
    }
  }

  private static <T> int binarySearch0(T[] paramArrayOfT, int paramInt1, int paramInt2, T paramT, Comparator<? super T> paramComparator)
  {
    int i;
    if (paramComparator == null)
      i = binarySearch0(paramArrayOfT, paramInt1, paramInt2, paramT);
    while (true)
    {
      return i;
      int j = paramInt1;
      int k = paramInt2 - 1;
      int m;
      while (true)
      {
        if (j > k)
        {
          i = -(j + 1);
          break;
        }
        m = j + k >>> 1;
        T ? = paramArrayOfT[m];
        int n = paramComparator.compare(?, paramT);
        if (n < 0)
        {
          j = m + 1;
          continue;
        }
        if (n <= 0)
          break label97;
        k = m - 1;
      }
      label97: i = m;
    }
  }

  private static int binarySearch0(short[] paramArrayOfShort, int paramInt1, int paramInt2, short paramShort)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    if (i > j);
    int m;
    for (int k = -(i + 1); ; k = m)
    {
      return k;
      m = i + j >>> 1;
      short s = paramArrayOfShort[m];
      if (s < paramShort)
      {
        i = m + 1;
        break;
      }
      if (s <= paramShort)
        continue;
      j = m - 1;
      break;
    }
  }

  public static byte[] copyOf(byte[] paramArrayOfByte, int paramInt)
  {
    byte[] arrayOfByte = new byte[paramInt];
    int i = Math.min(paramArrayOfByte.length, paramInt);
    System.arraycopy(paramArrayOfByte, 0, arrayOfByte, 0, i);
    return arrayOfByte;
  }

  public static char[] copyOf(char[] paramArrayOfChar, int paramInt)
  {
    char[] arrayOfChar = new char[paramInt];
    int i = Math.min(paramArrayOfChar.length, paramInt);
    System.arraycopy(paramArrayOfChar, 0, arrayOfChar, 0, i);
    return arrayOfChar;
  }

  public static double[] copyOf(double[] paramArrayOfDouble, int paramInt)
  {
    double[] arrayOfDouble = new double[paramInt];
    int i = Math.min(paramArrayOfDouble.length, paramInt);
    System.arraycopy(paramArrayOfDouble, 0, arrayOfDouble, 0, i);
    return arrayOfDouble;
  }

  public static float[] copyOf(float[] paramArrayOfFloat, int paramInt)
  {
    float[] arrayOfFloat = new float[paramInt];
    int i = Math.min(paramArrayOfFloat.length, paramInt);
    System.arraycopy(paramArrayOfFloat, 0, arrayOfFloat, 0, i);
    return arrayOfFloat;
  }

  public static int[] copyOf(int[] paramArrayOfInt, int paramInt)
  {
    int[] arrayOfInt = new int[paramInt];
    int i = Math.min(paramArrayOfInt.length, paramInt);
    System.arraycopy(paramArrayOfInt, 0, arrayOfInt, 0, i);
    return arrayOfInt;
  }

  public static long[] copyOf(long[] paramArrayOfLong, int paramInt)
  {
    int i = paramInt;
    int j = Math.min(paramArrayOfLong.length, paramInt);
    System.arraycopy(paramArrayOfLong, 0, i, 0, j);
    return i;
  }

  public static <T> T[] copyOf(T[] paramArrayOfT, int paramInt)
  {
    Class localClass = paramArrayOfT.getClass();
    return copyOf(paramArrayOfT, paramInt, localClass);
  }

  public static <T, U> T[] copyOf(U[] paramArrayOfU, int paramInt, Class<? extends T[]> paramClass)
  {
    if (paramClass == [Ljava.lang.Object.class);
    for (Object[] arrayOfObject = new Object[paramInt]; ; arrayOfObject = (Object[])Array.newInstance(paramClass.getComponentType(), paramInt))
    {
      int i = Math.min(paramArrayOfU.length, paramInt);
      System.arraycopy(paramArrayOfU, 0, arrayOfObject, 0, i);
      return arrayOfObject;
    }
  }

  public static short[] copyOf(short[] paramArrayOfShort, int paramInt)
  {
    int i = paramInt;
    int j = Math.min(paramArrayOfShort.length, paramInt);
    System.arraycopy(paramArrayOfShort, 0, i, 0, j);
    return i;
  }

  public static boolean[] copyOf(boolean[] paramArrayOfBoolean, int paramInt)
  {
    boolean[] arrayOfBoolean = new boolean[paramInt];
    int i = Math.min(paramArrayOfBoolean.length, paramInt);
    System.arraycopy(paramArrayOfBoolean, 0, arrayOfBoolean, 0, i);
    return arrayOfBoolean;
  }

  public static byte[] copyOfRange(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    byte[] arrayOfByte = new byte[i];
    int j = Math.min(paramArrayOfByte.length - paramInt1, i);
    System.arraycopy(paramArrayOfByte, paramInt1, arrayOfByte, 0, j);
    return arrayOfByte;
  }

  public static char[] copyOfRange(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    char[] arrayOfChar = new char[i];
    int j = Math.min(paramArrayOfChar.length - paramInt1, i);
    System.arraycopy(paramArrayOfChar, paramInt1, arrayOfChar, 0, j);
    return arrayOfChar;
  }

  public static double[] copyOfRange(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    double[] arrayOfDouble = new double[i];
    int j = Math.min(paramArrayOfDouble.length - paramInt1, i);
    System.arraycopy(paramArrayOfDouble, paramInt1, arrayOfDouble, 0, j);
    return arrayOfDouble;
  }

  public static float[] copyOfRange(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    float[] arrayOfFloat = new float[i];
    int j = Math.min(paramArrayOfFloat.length - paramInt1, i);
    System.arraycopy(paramArrayOfFloat, paramInt1, arrayOfFloat, 0, j);
    return arrayOfFloat;
  }

  public static int[] copyOfRange(int[] paramArrayOfInt, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    int[] arrayOfInt = new int[i];
    int j = Math.min(paramArrayOfInt.length - paramInt1, i);
    System.arraycopy(paramArrayOfInt, paramInt1, arrayOfInt, 0, j);
    return arrayOfInt;
  }

  public static long[] copyOfRange(long[] paramArrayOfLong, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    int j = i;
    int k = Math.min(paramArrayOfLong.length - paramInt1, i);
    System.arraycopy(paramArrayOfLong, paramInt1, j, 0, k);
    return j;
  }

  public static <T> T[] copyOfRange(T[] paramArrayOfT, int paramInt1, int paramInt2)
  {
    Class localClass = paramArrayOfT.getClass();
    return copyOfRange(paramArrayOfT, paramInt1, paramInt2, localClass);
  }

  public static <T, U> T[] copyOfRange(U[] paramArrayOfU, int paramInt1, int paramInt2, Class<? extends T[]> paramClass)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    if (paramClass == [Ljava.lang.Object.class);
    for (Object[] arrayOfObject = new Object[i]; ; arrayOfObject = (Object[])Array.newInstance(paramClass.getComponentType(), i))
    {
      int j = Math.min(paramArrayOfU.length - paramInt1, i);
      System.arraycopy(paramArrayOfU, paramInt1, arrayOfObject, 0, j);
      return arrayOfObject;
    }
  }

  public static short[] copyOfRange(short[] paramArrayOfShort, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    int j = i;
    int k = Math.min(paramArrayOfShort.length - paramInt1, i);
    System.arraycopy(paramArrayOfShort, paramInt1, j, 0, k);
    return j;
  }

  public static boolean[] copyOfRange(boolean[] paramArrayOfBoolean, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
    {
      String str1 = String.valueOf(paramInt1);
      String str2 = str1 + " > " + paramInt2;
      throw new IllegalArgumentException(str2);
    }
    boolean[] arrayOfBoolean = new boolean[i];
    int j = Math.min(paramArrayOfBoolean.length - paramInt1, i);
    System.arraycopy(paramArrayOfBoolean, paramInt1, arrayOfBoolean, 0, j);
    return arrayOfBoolean;
  }

  public static boolean deepEquals(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2)
  {
    int i;
    if (paramArrayOfObject1 == paramArrayOfObject2)
      i = 1;
    int k;
    while (true)
    {
      return i;
      if ((paramArrayOfObject1 == null) || (paramArrayOfObject2 == null))
      {
        i = 0;
        continue;
      }
      int j = paramArrayOfObject1.length;
      if (paramArrayOfObject2.length != j)
      {
        i = 0;
        continue;
      }
      k = 0;
      label39: if (k < j)
        break;
      i = 1;
    }
    Object localObject1 = paramArrayOfObject1[k];
    Object localObject2 = paramArrayOfObject2[k];
    if (localObject1 == localObject2);
    label483: 
    while (true)
    {
      k += 1;
      break label39;
      if (localObject1 == null)
      {
        i = 0;
        break;
      }
      boolean bool;
      if (((localObject1 instanceof Object[])) && ((localObject2 instanceof Object[])))
      {
        Object[] arrayOfObject1 = (Object[])localObject1;
        Object[] arrayOfObject2 = (Object[])localObject2;
        bool = deepEquals(arrayOfObject1, arrayOfObject2);
      }
      while (true)
      {
        if (bool)
          break label483;
        i = 0;
        break;
        if (((localObject1 instanceof byte[])) && ((localObject2 instanceof byte[])))
        {
          byte[] arrayOfByte1 = (byte[])localObject1;
          byte[] arrayOfByte2 = (byte[])localObject2;
          bool = equals(arrayOfByte1, arrayOfByte2);
          continue;
        }
        if (((localObject1 instanceof short[])) && ((localObject2 instanceof short[])))
        {
          short[] arrayOfShort1 = (short[])localObject1;
          short[] arrayOfShort2 = (short[])localObject2;
          bool = equals(arrayOfShort1, arrayOfShort2);
          continue;
        }
        if (((localObject1 instanceof int[])) && ((localObject2 instanceof int[])))
        {
          int[] arrayOfInt1 = (int[])localObject1;
          int[] arrayOfInt2 = (int[])localObject2;
          bool = equals(arrayOfInt1, arrayOfInt2);
          continue;
        }
        if (((localObject1 instanceof long[])) && ((localObject2 instanceof long[])))
        {
          long[] arrayOfLong1 = (long[])localObject1;
          long[] arrayOfLong2 = (long[])localObject2;
          bool = equals(arrayOfLong1, arrayOfLong2);
          continue;
        }
        if (((localObject1 instanceof char[])) && ((localObject2 instanceof char[])))
        {
          char[] arrayOfChar1 = (char[])localObject1;
          char[] arrayOfChar2 = (char[])localObject2;
          bool = equals(arrayOfChar1, arrayOfChar2);
          continue;
        }
        if (((localObject1 instanceof float[])) && ((localObject2 instanceof float[])))
        {
          float[] arrayOfFloat1 = (float[])localObject1;
          float[] arrayOfFloat2 = (float[])localObject2;
          bool = equals(arrayOfFloat1, arrayOfFloat2);
          continue;
        }
        if (((localObject1 instanceof double[])) && ((localObject2 instanceof double[])))
        {
          double[] arrayOfDouble1 = (double[])localObject1;
          double[] arrayOfDouble2 = (double[])localObject2;
          bool = equals(arrayOfDouble1, arrayOfDouble2);
          continue;
        }
        if (((localObject1 instanceof boolean[])) && ((localObject2 instanceof boolean[])))
        {
          boolean[] arrayOfBoolean1 = (boolean[])localObject1;
          boolean[] arrayOfBoolean2 = (boolean[])localObject2;
          bool = equals(arrayOfBoolean1, arrayOfBoolean2);
          continue;
        }
        bool = localObject1.equals(localObject2);
      }
    }
  }

  public static int deepHashCode(Object[] paramArrayOfObject)
  {
    int i = 0;
    if (paramArrayOfObject == null);
    int k;
    for (int j = 0; ; j = k)
    {
      return j;
      k = 1;
      j = paramArrayOfObject.length;
      if (i < j)
        break;
    }
    Object localObject = paramArrayOfObject[i];
    int m = 0;
    if ((localObject instanceof Object[]))
      m = deepHashCode((Object[])localObject);
    while (true)
    {
      k = k * 31 + m;
      i += 1;
      break;
      if ((localObject instanceof byte[]))
      {
        m = hashCode((byte[])localObject);
        continue;
      }
      if ((localObject instanceof short[]))
      {
        m = hashCode((short[])localObject);
        continue;
      }
      if ((localObject instanceof int[]))
      {
        m = hashCode((int[])localObject);
        continue;
      }
      if ((localObject instanceof long[]))
      {
        m = hashCode((long[])localObject);
        continue;
      }
      if ((localObject instanceof char[]))
      {
        m = hashCode((char[])localObject);
        continue;
      }
      if ((localObject instanceof float[]))
      {
        m = hashCode((float[])localObject);
        continue;
      }
      if ((localObject instanceof double[]))
      {
        m = hashCode((double[])localObject);
        continue;
      }
      if ((localObject instanceof boolean[]))
      {
        m = hashCode((boolean[])localObject);
        continue;
      }
      if (localObject == null)
        continue;
      m = localObject.hashCode();
    }
  }

  public static String deepToString(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null);
    StringBuilder localStringBuilder;
    for (String str = "null"; ; str = localStringBuilder.toString())
    {
      return str;
      int i = paramArrayOfObject.length * 20;
      if ((paramArrayOfObject.length != 0) && (i <= 0))
        i = 2147483647;
      localStringBuilder = new StringBuilder(i);
      HashSet localHashSet = new HashSet();
      deepToString(paramArrayOfObject, localStringBuilder, localHashSet);
    }
  }

  private static void deepToString(Object[] paramArrayOfObject, StringBuilder paramStringBuilder, Set<Object[]> paramSet)
  {
    if (paramArrayOfObject == null)
      StringBuilder localStringBuilder1 = paramStringBuilder.append("null");
    int i;
    while (true)
    {
      return;
      boolean bool1 = paramSet.add(paramArrayOfObject);
      StringBuilder localStringBuilder2 = paramStringBuilder.append(91);
      i = 0;
      int j = paramArrayOfObject.length;
      if (i < j)
        break;
      StringBuilder localStringBuilder3 = paramStringBuilder.append(93);
      boolean bool2 = paramSet.remove(paramArrayOfObject);
    }
    if (i != 0)
      StringBuilder localStringBuilder4 = paramStringBuilder.append(", ");
    Object localObject = paramArrayOfObject[i];
    if (localObject == null)
      StringBuilder localStringBuilder5 = paramStringBuilder.append("null");
    while (true)
    {
      i += 1;
      break;
      Class localClass = localObject.getClass();
      if (localClass.isArray())
      {
        if (localClass == [B.class)
        {
          String str1 = toString((byte[])localObject);
          StringBuilder localStringBuilder6 = paramStringBuilder.append(str1);
          continue;
        }
        if (localClass == [S.class)
        {
          String str2 = toString((short[])localObject);
          StringBuilder localStringBuilder7 = paramStringBuilder.append(str2);
          continue;
        }
        if (localClass == [I.class)
        {
          String str3 = toString((int[])localObject);
          StringBuilder localStringBuilder8 = paramStringBuilder.append(str3);
          continue;
        }
        if (localClass == [J.class)
        {
          String str4 = toString((long[])localObject);
          StringBuilder localStringBuilder9 = paramStringBuilder.append(str4);
          continue;
        }
        if (localClass == [C.class)
        {
          String str5 = toString((char[])localObject);
          StringBuilder localStringBuilder10 = paramStringBuilder.append(str5);
          continue;
        }
        if (localClass == [F.class)
        {
          String str6 = toString((float[])localObject);
          StringBuilder localStringBuilder11 = paramStringBuilder.append(str6);
          continue;
        }
        if (localClass == [D.class)
        {
          String str7 = toString((double[])localObject);
          StringBuilder localStringBuilder12 = paramStringBuilder.append(str7);
          continue;
        }
        if (localClass == [Z.class)
        {
          String str8 = toString((boolean[])localObject);
          StringBuilder localStringBuilder13 = paramStringBuilder.append(str8);
          continue;
        }
        if (paramSet.contains(localObject))
        {
          StringBuilder localStringBuilder14 = paramStringBuilder.append("[...]");
          continue;
        }
        deepToString((Object[])localObject, paramStringBuilder, paramSet);
        continue;
      }
      String str9 = localObject.toString();
      StringBuilder localStringBuilder15 = paramStringBuilder.append(str9);
    }
  }

  public static boolean equals(byte[] paramArrayOfByte1, byte[] paramArrayOfByte2)
  {
    int i;
    if (paramArrayOfByte1 == paramArrayOfByte2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfByte1 == null) || (paramArrayOfByte2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfByte1.length;
      if (paramArrayOfByte2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      int m = paramArrayOfByte1[k];
      int n = paramArrayOfByte2[k];
      if (m != n)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(char[] paramArrayOfChar1, char[] paramArrayOfChar2)
  {
    int i;
    if (paramArrayOfChar1 == paramArrayOfChar2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfChar1 == null) || (paramArrayOfChar2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfChar1.length;
      if (paramArrayOfChar2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      int m = paramArrayOfChar1[k];
      int n = paramArrayOfChar2[k];
      if (m != n)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(double[] paramArrayOfDouble1, double[] paramArrayOfDouble2)
  {
    int i;
    if (paramArrayOfDouble1 == paramArrayOfDouble2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfDouble1 == null) || (paramArrayOfDouble2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfDouble1.length;
      if (paramArrayOfDouble2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      long l1 = Double.doubleToLongBits(paramArrayOfDouble1[k]);
      long l2 = Double.doubleToLongBits(paramArrayOfDouble2[k]);
      if (l1 != l2)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(float[] paramArrayOfFloat1, float[] paramArrayOfFloat2)
  {
    int i;
    if (paramArrayOfFloat1 == paramArrayOfFloat2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfFloat1 == null) || (paramArrayOfFloat2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfFloat1.length;
      if (paramArrayOfFloat2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      int m = Float.floatToIntBits(paramArrayOfFloat1[k]);
      int n = Float.floatToIntBits(paramArrayOfFloat2[k]);
      if (m != n)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(int[] paramArrayOfInt1, int[] paramArrayOfInt2)
  {
    int i;
    if (paramArrayOfInt1 == paramArrayOfInt2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfInt1 == null) || (paramArrayOfInt2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfInt1.length;
      if (paramArrayOfInt2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      int m = paramArrayOfInt1[k];
      int n = paramArrayOfInt2[k];
      if (m != n)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(long[] paramArrayOfLong1, long[] paramArrayOfLong2)
  {
    int i;
    if (paramArrayOfLong1 == paramArrayOfLong2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfLong1 == null) || (paramArrayOfLong2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfLong1.length;
      if (paramArrayOfLong2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      long l1 = paramArrayOfLong1[k];
      long l2 = paramArrayOfLong2[k];
      if (l1 != l2)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2)
  {
    int i;
    if (paramArrayOfObject1 == paramArrayOfObject2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfObject1 == null) || (paramArrayOfObject2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfObject1.length;
      if (paramArrayOfObject2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      Object localObject1 = paramArrayOfObject1[k];
      Object localObject2 = paramArrayOfObject2[k];
      if (localObject1 == null)
      {
        if (localObject2 == null);
      }
      else
        do
        {
          i = 0;
          break;
        }
        while (!localObject1.equals(localObject2));
      k += 1;
    }
  }

  public static boolean equals(short[] paramArrayOfShort1, short[] paramArrayOfShort2)
  {
    int i;
    if (paramArrayOfShort1 == paramArrayOfShort2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfShort1 == null) || (paramArrayOfShort2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfShort1.length;
      if (paramArrayOfShort2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      int m = paramArrayOfShort1[k];
      int n = paramArrayOfShort2[k];
      if (m != n)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static boolean equals(boolean[] paramArrayOfBoolean1, boolean[] paramArrayOfBoolean2)
  {
    int i;
    if (paramArrayOfBoolean1 == paramArrayOfBoolean2)
      i = 1;
    int j;
    while (true)
    {
      return i;
      if ((paramArrayOfBoolean1 == null) || (paramArrayOfBoolean2 == null))
      {
        i = 0;
        continue;
      }
      j = paramArrayOfBoolean1.length;
      if (paramArrayOfBoolean2.length == j)
        break;
      i = 0;
    }
    int k = 0;
    while (true)
    {
      if (k >= j)
      {
        i = 1;
        break;
      }
      int m = paramArrayOfBoolean1[k];
      int n = paramArrayOfBoolean2[k];
      if (m != n)
      {
        i = 0;
        break;
      }
      k += 1;
    }
  }

  public static void fill(byte[] paramArrayOfByte, byte paramByte)
  {
    int i = paramArrayOfByte.length;
    fill(paramArrayOfByte, 0, i, paramByte);
  }

  public static void fill(byte[] paramArrayOfByte, int paramInt1, int paramInt2, byte paramByte)
  {
    rangeCheck(paramArrayOfByte.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfByte[i] = paramByte;
      i += 1;
    }
  }

  public static void fill(char[] paramArrayOfChar, char paramChar)
  {
    int i = paramArrayOfChar.length;
    fill(paramArrayOfChar, 0, i, paramChar);
  }

  public static void fill(char[] paramArrayOfChar, int paramInt1, int paramInt2, char paramChar)
  {
    rangeCheck(paramArrayOfChar.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfChar[i] = paramChar;
      i += 1;
    }
  }

  public static void fill(double[] paramArrayOfDouble, double paramDouble)
  {
    int i = paramArrayOfDouble.length;
    fill(paramArrayOfDouble, 0, i, paramDouble);
  }

  public static void fill(double[] paramArrayOfDouble, int paramInt1, int paramInt2, double paramDouble)
  {
    rangeCheck(paramArrayOfDouble.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfDouble[i] = paramDouble;
      i += 1;
    }
  }

  public static void fill(float[] paramArrayOfFloat, float paramFloat)
  {
    int i = paramArrayOfFloat.length;
    fill(paramArrayOfFloat, 0, i, paramFloat);
  }

  public static void fill(float[] paramArrayOfFloat, int paramInt1, int paramInt2, float paramFloat)
  {
    rangeCheck(paramArrayOfFloat.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfFloat[i] = paramFloat;
      i += 1;
    }
  }

  public static void fill(int[] paramArrayOfInt, int paramInt)
  {
    int i = paramArrayOfInt.length;
    fill(paramArrayOfInt, 0, i, paramInt);
  }

  public static void fill(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    rangeCheck(paramArrayOfInt.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfInt[i] = paramInt3;
      i += 1;
    }
  }

  public static void fill(long[] paramArrayOfLong, int paramInt1, int paramInt2, long paramLong)
  {
    rangeCheck(paramArrayOfLong.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfLong[i] = paramLong;
      i += 1;
    }
  }

  public static void fill(long[] paramArrayOfLong, long paramLong)
  {
    int i = paramArrayOfLong.length;
    fill(paramArrayOfLong, 0, i, paramLong);
  }

  public static void fill(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Object paramObject)
  {
    rangeCheck(paramArrayOfObject.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfObject[i] = paramObject;
      i += 1;
    }
  }

  public static void fill(Object[] paramArrayOfObject, Object paramObject)
  {
    int i = paramArrayOfObject.length;
    fill(paramArrayOfObject, 0, i, paramObject);
  }

  public static void fill(short[] paramArrayOfShort, int paramInt1, int paramInt2, short paramShort)
  {
    rangeCheck(paramArrayOfShort.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfShort[i] = paramShort;
      i += 1;
    }
  }

  public static void fill(short[] paramArrayOfShort, short paramShort)
  {
    int i = paramArrayOfShort.length;
    fill(paramArrayOfShort, 0, i, paramShort);
  }

  public static void fill(boolean[] paramArrayOfBoolean, int paramInt1, int paramInt2, boolean paramBoolean)
  {
    rangeCheck(paramArrayOfBoolean.length, paramInt1, paramInt2);
    int i = paramInt1;
    while (true)
    {
      if (i >= paramInt2)
        return;
      paramArrayOfBoolean[i] = paramBoolean;
      i += 1;
    }
  }

  public static void fill(boolean[] paramArrayOfBoolean, boolean paramBoolean)
  {
    int i = paramArrayOfBoolean.length;
    fill(paramArrayOfBoolean, 0, i, paramBoolean);
  }

  public static int hashCode(byte[] paramArrayOfByte)
  {
    int i = 0;
    if (paramArrayOfByte == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfByte.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      int m = paramArrayOfByte[i];
      k = k * 31 + m;
      i += 1;
    }
  }

  public static int hashCode(char[] paramArrayOfChar)
  {
    int i = 0;
    if (paramArrayOfChar == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfChar.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      int m = paramArrayOfChar[i];
      k = k * 31 + m;
      i += 1;
    }
  }

  public static int hashCode(double[] paramArrayOfDouble)
  {
    int i = 0;
    if (paramArrayOfDouble == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfDouble.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      long l = Double.doubleToLongBits(paramArrayOfDouble[i]);
      int m = k * 31;
      int n = (int)(l >>> 32 ^ l);
      k = m + n;
      i += 1;
    }
  }

  public static int hashCode(float[] paramArrayOfFloat)
  {
    int i = 0;
    if (paramArrayOfFloat == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfFloat.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      int m = paramArrayOfFloat[i];
      int n = k * 31;
      int i1 = Float.floatToIntBits(m);
      k = n + i1;
      i += 1;
    }
  }

  public static int hashCode(int[] paramArrayOfInt)
  {
    int i = 0;
    if (paramArrayOfInt == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfInt.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      int m = paramArrayOfInt[i];
      k = k * 31 + m;
      i += 1;
    }
  }

  public static int hashCode(long[] paramArrayOfLong)
  {
    int i = 0;
    if (paramArrayOfLong == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfLong.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      long l = paramArrayOfLong[i];
      int m = (int)(l >>> 32 ^ l);
      k = k * 31 + m;
      i += 1;
    }
  }

  public static int hashCode(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null);
    int j;
    int k;
    for (int i = 0; ; i = j)
    {
      return i;
      j = 1;
      i = paramArrayOfObject.length;
      k = 0;
      if (k < i)
        break;
    }
    Object localObject = paramArrayOfObject[k];
    int m = j * 31;
    if (localObject == null);
    for (int n = 0; ; n = localObject.hashCode())
    {
      j = m + n;
      k += 1;
      break;
    }
  }

  public static int hashCode(short[] paramArrayOfShort)
  {
    int i = 0;
    if (paramArrayOfShort == null)
    {
      j = 0;
      return j;
    }
    int k = 1;
    int j = paramArrayOfShort.length;
    while (true)
    {
      if (i >= j)
      {
        j = k;
        break;
      }
      int m = paramArrayOfShort[i];
      k = k * 31 + m;
      i += 1;
    }
  }

  public static int hashCode(boolean[] paramArrayOfBoolean)
  {
    int i = 0;
    if (paramArrayOfBoolean == null);
    int k;
    for (int j = 0; ; j = k)
    {
      return j;
      k = 1;
      j = paramArrayOfBoolean.length;
      if (i < j)
        break;
    }
    int m = paramArrayOfBoolean[i];
    int n = k * 31;
    if (m != 0);
    for (int i1 = 1231; ; i1 = 1237)
    {
      k = n + i1;
      i += 1;
      break;
    }
  }

  private static int med3(byte[] paramArrayOfByte, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramArrayOfByte[paramInt1];
    int j = paramArrayOfByte[paramInt2];
    int n;
    if (i < j)
    {
      int k = paramArrayOfByte[paramInt2];
      int m = paramArrayOfByte[paramInt3];
      if (k < m)
        n = paramInt2;
    }
    while (true)
    {
      return n;
      int i1 = paramArrayOfByte[paramInt1];
      int i2 = paramArrayOfByte[paramInt3];
      if (i1 < i2)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
      continue;
      int i3 = paramArrayOfByte[paramInt2];
      int i4 = paramArrayOfByte[paramInt3];
      if (i3 > i4)
      {
        n = paramInt2;
        continue;
      }
      int i5 = paramArrayOfByte[paramInt1];
      int i6 = paramArrayOfByte[paramInt3];
      if (i5 > i6)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
    }
  }

  private static int med3(char[] paramArrayOfChar, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramArrayOfChar[paramInt1];
    int j = paramArrayOfChar[paramInt2];
    int n;
    if (i < j)
    {
      int k = paramArrayOfChar[paramInt2];
      int m = paramArrayOfChar[paramInt3];
      if (k < m)
        n = paramInt2;
    }
    while (true)
    {
      return n;
      int i1 = paramArrayOfChar[paramInt1];
      int i2 = paramArrayOfChar[paramInt3];
      if (i1 < i2)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
      continue;
      int i3 = paramArrayOfChar[paramInt2];
      int i4 = paramArrayOfChar[paramInt3];
      if (i3 > i4)
      {
        n = paramInt2;
        continue;
      }
      int i5 = paramArrayOfChar[paramInt1];
      int i6 = paramArrayOfChar[paramInt3];
      if (i5 > i6)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
    }
  }

  private static int med3(double[] paramArrayOfDouble, int paramInt1, int paramInt2, int paramInt3)
  {
    long l1 = paramArrayOfDouble[paramInt1];
    long l2 = paramArrayOfDouble[paramInt2];
    int i;
    if (l1 < l2)
    {
      long l3 = paramArrayOfDouble[paramInt2];
      long l4 = paramArrayOfDouble[paramInt3];
      if (l3 < l4)
        i = paramInt2;
    }
    while (true)
    {
      return i;
      long l5 = paramArrayOfDouble[paramInt1];
      long l6 = paramArrayOfDouble[paramInt3];
      if (l5 < l6)
      {
        i = paramInt3;
        continue;
      }
      i = paramInt1;
      continue;
      long l7 = paramArrayOfDouble[paramInt2];
      long l8 = paramArrayOfDouble[paramInt3];
      if (l7 > l8)
      {
        i = paramInt2;
        continue;
      }
      long l9 = paramArrayOfDouble[paramInt1];
      long l10 = paramArrayOfDouble[paramInt3];
      if (l9 > l10)
      {
        i = paramInt3;
        continue;
      }
      i = paramInt1;
    }
  }

  private static int med3(float[] paramArrayOfFloat, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramArrayOfFloat[paramInt1];
    int j = paramArrayOfFloat[paramInt2];
    int n;
    if (i < j)
    {
      int k = paramArrayOfFloat[paramInt2];
      int m = paramArrayOfFloat[paramInt3];
      if (k < m)
        n = paramInt2;
    }
    while (true)
    {
      return n;
      int i1 = paramArrayOfFloat[paramInt1];
      int i2 = paramArrayOfFloat[paramInt3];
      if (i1 < i2)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
      continue;
      int i3 = paramArrayOfFloat[paramInt2];
      int i4 = paramArrayOfFloat[paramInt3];
      if (i3 > i4)
      {
        n = paramInt2;
        continue;
      }
      int i5 = paramArrayOfFloat[paramInt1];
      int i6 = paramArrayOfFloat[paramInt3];
      if (i5 > i6)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
    }
  }

  private static int med3(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramArrayOfInt[paramInt1];
    int j = paramArrayOfInt[paramInt2];
    int n;
    if (i < j)
    {
      int k = paramArrayOfInt[paramInt2];
      int m = paramArrayOfInt[paramInt3];
      if (k < m)
        n = paramInt2;
    }
    while (true)
    {
      return n;
      int i1 = paramArrayOfInt[paramInt1];
      int i2 = paramArrayOfInt[paramInt3];
      if (i1 < i2)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
      continue;
      int i3 = paramArrayOfInt[paramInt2];
      int i4 = paramArrayOfInt[paramInt3];
      if (i3 > i4)
      {
        n = paramInt2;
        continue;
      }
      int i5 = paramArrayOfInt[paramInt1];
      int i6 = paramArrayOfInt[paramInt3];
      if (i5 > i6)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
    }
  }

  private static int med3(long[] paramArrayOfLong, int paramInt1, int paramInt2, int paramInt3)
  {
    long l1 = paramArrayOfLong[paramInt1];
    long l2 = paramArrayOfLong[paramInt2];
    int i;
    if (l1 < l2)
    {
      long l3 = paramArrayOfLong[paramInt2];
      long l4 = paramArrayOfLong[paramInt3];
      if (l3 < l4)
        i = paramInt2;
    }
    while (true)
    {
      return i;
      long l5 = paramArrayOfLong[paramInt1];
      long l6 = paramArrayOfLong[paramInt3];
      if (l5 < l6)
      {
        i = paramInt3;
        continue;
      }
      i = paramInt1;
      continue;
      long l7 = paramArrayOfLong[paramInt2];
      long l8 = paramArrayOfLong[paramInt3];
      if (l7 > l8)
      {
        i = paramInt2;
        continue;
      }
      long l9 = paramArrayOfLong[paramInt1];
      long l10 = paramArrayOfLong[paramInt3];
      if (l9 > l10)
      {
        i = paramInt3;
        continue;
      }
      i = paramInt1;
    }
  }

  private static int med3(short[] paramArrayOfShort, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramArrayOfShort[paramInt1];
    int j = paramArrayOfShort[paramInt2];
    int n;
    if (i < j)
    {
      int k = paramArrayOfShort[paramInt2];
      int m = paramArrayOfShort[paramInt3];
      if (k < m)
        n = paramInt2;
    }
    while (true)
    {
      return n;
      int i1 = paramArrayOfShort[paramInt1];
      int i2 = paramArrayOfShort[paramInt3];
      if (i1 < i2)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
      continue;
      int i3 = paramArrayOfShort[paramInt2];
      int i4 = paramArrayOfShort[paramInt3];
      if (i3 > i4)
      {
        n = paramInt2;
        continue;
      }
      int i5 = paramArrayOfShort[paramInt1];
      int i6 = paramArrayOfShort[paramInt3];
      if (i5 > i6)
      {
        n = paramInt3;
        continue;
      }
      n = paramInt1;
    }
  }

  private static void mergeSort(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramInt2 - paramInt1;
    if (i < 7)
    {
      paramArrayOfObject1 = paramInt1;
      if (paramArrayOfObject1 < paramInt2);
    }
    int m;
    int n;
    int i1;
    while (true)
    {
      return;
      paramInt3 = paramArrayOfObject1;
      while (true)
      {
        if (paramInt3 > paramInt1)
        {
          int j = paramInt3 - 1;
          Comparable localComparable1 = (Comparable)paramArrayOfObject2[j];
          Object localObject1 = paramArrayOfObject2[paramInt3];
          if (localComparable1.compareTo(localObject1) > 0);
        }
        else
        {
          paramArrayOfObject1 += 1;
          break;
        }
        int k = paramInt3 - 1;
        swap(paramArrayOfObject2, paramInt3, k);
        paramInt3 += -1;
      }
      m = paramInt1;
      n = paramInt2;
      paramInt1 += paramInt3;
      paramInt2 += paramInt3;
      i1 = paramInt1 + paramInt2 >>> 1;
      int i2 = -paramInt3;
      mergeSort(paramArrayOfObject2, paramArrayOfObject1, paramInt1, i1, i2);
      int i3 = -paramInt3;
      mergeSort(paramArrayOfObject2, paramArrayOfObject1, i1, paramInt2, i3);
      int i4 = i1 - 1;
      Comparable localComparable2 = (Comparable)paramArrayOfObject1[i4];
      Object localObject2 = paramArrayOfObject1[i1];
      if (localComparable2.compareTo(localObject2) > 0)
        break label192;
      System.arraycopy(paramArrayOfObject1, paramInt1, paramArrayOfObject2, m, i);
    }
    label192: paramInt3 = m;
    int i5 = paramInt1;
    int i6 = i1;
    i = i5;
    label207: if (paramInt3 < n)
    {
      if (i6 < paramInt2)
      {
        if (i >= i1)
          break label293;
        Comparable localComparable3 = (Comparable)paramArrayOfObject1[i];
        Object localObject3 = paramArrayOfObject1[i6];
        if (localComparable3.compareTo(localObject3) > 0)
          break label293;
      }
      m = i + 1;
      Object localObject4 = paramArrayOfObject1[i];
      paramArrayOfObject2[paramInt3] = localObject4;
    }
    label293: int i8;
    for (i = i6; ; i = i8)
    {
      paramInt3 += 1;
      i6 = i;
      i = m;
      break label207;
      break;
      int i7 = i6 + 1;
      Object localObject5 = paramArrayOfObject1[i6];
      paramArrayOfObject2[paramInt3] = localObject5;
      i8 = i7;
      m = i;
    }
  }

  private static void mergeSort(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2, int paramInt1, int paramInt2, int paramInt3, Comparator paramComparator)
  {
    int i = paramInt2 - paramInt1;
    if (i < 7)
    {
      paramArrayOfObject1 = paramInt1;
      int j = paramArrayOfObject1;
      int k = paramInt2;
      if (j < k);
    }
    int i7;
    label298: int i17;
    int i19;
    int i20;
    do
    {
      int i5;
      int i6;
      while (true)
      {
        return;
        paramInt3 = paramArrayOfObject1;
        while (true)
        {
          int m = paramInt3;
          int n = paramInt1;
          if (m > n)
          {
            int i1 = paramInt3 - 1;
            Object localObject1 = paramArrayOfObject2[i1];
            Object localObject2 = paramArrayOfObject2[paramInt3];
            Comparator localComparator1 = paramComparator;
            Object localObject3 = localObject1;
            Object localObject4 = localObject2;
            if (localComparator1.compare(localObject3, localObject4) > 0);
          }
          else
          {
            paramArrayOfObject1 += 1;
            break;
          }
          int i2 = paramInt3 - 1;
          Object[] arrayOfObject1 = paramArrayOfObject2;
          int i3 = paramInt3;
          int i4 = i2;
          swap(arrayOfObject1, i3, i4);
          paramInt3 += -1;
        }
        i5 = paramInt1;
        i6 = paramInt2;
        paramInt1 += paramInt3;
        paramInt2 += paramInt3;
        i7 = paramInt1 + paramInt2 >>> 1;
        int i8 = -paramInt3;
        Object[] arrayOfObject2 = paramArrayOfObject2;
        Object[] arrayOfObject3 = paramArrayOfObject1;
        int i9 = paramInt1;
        Comparator localComparator2 = paramComparator;
        mergeSort(arrayOfObject2, arrayOfObject3, i9, i7, i8, localComparator2);
        int i10 = -paramInt3;
        Object[] arrayOfObject4 = paramArrayOfObject2;
        Object[] arrayOfObject5 = paramArrayOfObject1;
        int i11 = paramInt2;
        Comparator localComparator3 = paramComparator;
        mergeSort(arrayOfObject4, arrayOfObject5, i7, i11, i10, localComparator3);
        int i12 = i7 - 1;
        Object localObject5 = paramArrayOfObject1[i12];
        Object localObject6 = paramArrayOfObject1[i7];
        Comparator localComparator4 = paramComparator;
        Object localObject7 = localObject5;
        Object localObject8 = localObject6;
        if (localComparator4.compare(localObject7, localObject8) > 0)
          break label298;
        Object[] arrayOfObject6 = paramArrayOfObject1;
        int i13 = paramInt1;
        Object[] arrayOfObject7 = paramArrayOfObject2;
        int i14 = i5;
        int i15 = i;
        System.arraycopy(arrayOfObject6, i13, arrayOfObject7, i14, i15);
      }
      paramInt3 = i5;
      int i16 = paramInt1;
      i17 = i7;
      i18 = i16;
      i19 = paramInt3;
      i20 = i6;
    }
    while (i19 >= i20);
    int i21 = i17;
    int i22 = paramInt2;
    int i23;
    if (i21 < i22)
    {
      if (i18 < i7)
      {
        Object localObject9 = paramArrayOfObject1[i18];
        Object localObject10 = paramArrayOfObject1[i17];
        Comparator localComparator5 = paramComparator;
        Object localObject11 = localObject9;
        Object localObject12 = localObject10;
        if (localComparator5.compare(localObject11, localObject12) > 0);
      }
    }
    else
    {
      i23 = i18 + 1;
      Object localObject13 = paramArrayOfObject1[i18];
      paramArrayOfObject2[paramInt3] = localObject13;
    }
    int i25;
    for (int i18 = i17; ; i18 = i25)
    {
      paramInt3 += 1;
      i17 = i18;
      i18 = i23;
      break;
      int i24 = i17 + 1;
      Object localObject14 = paramArrayOfObject1[i17];
      paramArrayOfObject2[paramInt3] = localObject14;
      i25 = i24;
      i23 = i18;
    }
  }

  private static void rangeCheck(int paramInt1, int paramInt2, int paramInt3)
  {
    if (paramInt2 > paramInt3)
    {
      String str = "fromIndex(" + paramInt2 + ") > toIndex(" + paramInt3 + ")";
      throw new IllegalArgumentException(str);
    }
    if (paramInt2 < 0)
      throw new ArrayIndexOutOfBoundsException(paramInt2);
    if (paramInt3 > paramInt1)
      throw new ArrayIndexOutOfBoundsException(paramInt3);
  }

  public static void sort(byte[] paramArrayOfByte)
  {
    int i = paramArrayOfByte.length;
    sort1(paramArrayOfByte, 0, i);
  }

  public static void sort(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfByte.length, paramInt1, paramInt2);
    int i = paramInt2 - paramInt1;
    sort1(paramArrayOfByte, paramInt1, i);
  }

  public static void sort(char[] paramArrayOfChar)
  {
    int i = paramArrayOfChar.length;
    sort1(paramArrayOfChar, 0, i);
  }

  public static void sort(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfChar.length, paramInt1, paramInt2);
    int i = paramInt2 - paramInt1;
    sort1(paramArrayOfChar, paramInt1, i);
  }

  public static void sort(double[] paramArrayOfDouble)
  {
    int i = paramArrayOfDouble.length;
    sort2(paramArrayOfDouble, 0, i);
  }

  public static void sort(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfDouble.length, paramInt1, paramInt2);
    sort2(paramArrayOfDouble, paramInt1, paramInt2);
  }

  public static void sort(float[] paramArrayOfFloat)
  {
    int i = paramArrayOfFloat.length;
    sort2(paramArrayOfFloat, 0, i);
  }

  public static void sort(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfFloat.length, paramInt1, paramInt2);
    sort2(paramArrayOfFloat, paramInt1, paramInt2);
  }

  public static void sort(int[] paramArrayOfInt)
  {
    int i = paramArrayOfInt.length;
    sort1(paramArrayOfInt, 0, i);
  }

  public static void sort(int[] paramArrayOfInt, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfInt.length, paramInt1, paramInt2);
    int i = paramInt2 - paramInt1;
    sort1(paramArrayOfInt, paramInt1, i);
  }

  public static void sort(long[] paramArrayOfLong)
  {
    int i = paramArrayOfLong.length;
    sort1(paramArrayOfLong, 0, i);
  }

  public static void sort(long[] paramArrayOfLong, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfLong.length, paramInt1, paramInt2);
    int i = paramInt2 - paramInt1;
    sort1(paramArrayOfLong, paramInt1, i);
  }

  public static void sort(Object[] paramArrayOfObject)
  {
    Object[] arrayOfObject = (Object[])paramArrayOfObject.clone();
    int i = paramArrayOfObject.length;
    mergeSort(arrayOfObject, paramArrayOfObject, 0, i, 0);
  }

  public static void sort(Object[] paramArrayOfObject, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfObject.length, paramInt1, paramInt2);
    Object[] arrayOfObject = copyOfRange(paramArrayOfObject, paramInt1, paramInt2);
    int i = -paramInt1;
    mergeSort(arrayOfObject, paramArrayOfObject, paramInt1, paramInt2, i);
  }

  public static <T> void sort(T[] paramArrayOfT, int paramInt1, int paramInt2, Comparator<? super T> paramComparator)
  {
    rangeCheck(paramArrayOfT.length, paramInt1, paramInt2);
    Object[] arrayOfObject = copyOfRange(paramArrayOfT, paramInt1, paramInt2);
    if (paramComparator == null)
    {
      int i = -paramInt1;
      mergeSort(arrayOfObject, paramArrayOfT, paramInt1, paramInt2, i);
    }
    while (true)
    {
      return;
      int j = -paramInt1;
      T[] arrayOfT = paramArrayOfT;
      int k = paramInt1;
      int m = paramInt2;
      Comparator<? super T> localComparator = paramComparator;
      mergeSort(arrayOfObject, arrayOfT, k, m, j, localComparator);
    }
  }

  public static <T> void sort(T[] paramArrayOfT, Comparator<? super T> paramComparator)
  {
    Object[] arrayOfObject = (Object[])paramArrayOfT.clone();
    if (paramComparator == null)
    {
      int i = paramArrayOfT.length;
      mergeSort(arrayOfObject, paramArrayOfT, 0, i, 0);
    }
    while (true)
    {
      return;
      int j = paramArrayOfT.length;
      T[] arrayOfT = paramArrayOfT;
      int k = 0;
      Comparator<? super T> localComparator = paramComparator;
      mergeSort(arrayOfObject, arrayOfT, 0, j, k, localComparator);
    }
  }

  public static void sort(short[] paramArrayOfShort)
  {
    int i = paramArrayOfShort.length;
    sort1(paramArrayOfShort, 0, i);
  }

  public static void sort(short[] paramArrayOfShort, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfShort.length, paramInt1, paramInt2);
    int i = paramInt2 - paramInt1;
    sort1(paramArrayOfShort, paramInt1, i);
  }

  private static void sort1(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          int n = paramArrayOfByte[m];
          int i1 = paramArrayOfByte[k];
          if (n > i1);
        }
        else
        {
          i += 1;
          break;
        }
        int i2 = k - 1;
        swap(paramArrayOfByte, k, i2);
        k += -1;
      }
    }
    int i3 = paramInt2 >> 1;
    int k = paramInt1 + i3;
    int i4;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i4 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i5 = paramInt2 / 8;
        int i6 = i + i5;
        int i7 = i5 * 2 + i;
        i = med3(paramArrayOfByte, i, i6, i7);
        int i8 = k - i5;
        int i9 = k + i5;
        k = med3(paramArrayOfByte, i8, k, i9);
        int i10 = i5 * 2;
        int i11 = i4 - i10;
        int i12 = i4 - i5;
        i4 = med3(paramArrayOfByte, i11, i12, i4);
      }
    }
    for (int i = med3(paramArrayOfByte, i, k, i4); ; i = k)
    {
      int i13 = paramArrayOfByte[i];
      int i14 = paramInt1;
      int i15 = i14;
      int i16 = paramInt1 + paramInt2 - 1;
      int i17 = i16;
      int i18 = i16;
      i4 = i15;
      k = i14;
      int i19;
      if (i4 <= i18)
        if (paramArrayOfByte[i4] > i13)
        {
          i19 = i17;
          i17 = i18;
        }
      while (true)
      {
        label274: if ((i17 < i4) || (paramArrayOfByte[i17] < i13))
        {
          if (i4 <= i17)
            break label502;
          paramInt2 += paramInt1;
          int i20 = k - paramInt1;
          int i21 = i4 - k;
          int i22 = Math.min(i20, i21);
          int i23 = i4 - i22;
          vecswap(paramArrayOfByte, paramInt1, i23, i22);
          int i24 = i19 - i17;
          int i25 = paramInt2 - i19 - 1;
          int i26 = Math.min(i24, i25);
          int i27 = paramInt2 - i26;
          vecswap(paramArrayOfByte, i4, i27, i26);
          i = i4 - k;
          if (i > 1)
            sort1(paramArrayOfByte, paramInt1, i);
          paramInt1 = i19 - i17;
          if (paramInt1 <= 1)
            break;
          int i28 = paramInt2 - paramInt1;
          sort1(paramArrayOfByte, i28, paramInt1);
          break;
          if (paramArrayOfByte[i4] != i13)
            break label541;
          i = k + 1;
          swap(paramArrayOfByte, k, i4);
        }
        while (true)
        {
          i4 += 1;
          k = i;
          break;
          int i29;
          if (paramArrayOfByte[i17] == i13)
          {
            i29 = i19 + -1;
            swap(paramArrayOfByte, i17, i19);
          }
          for (i18 = i29; ; i18 = i19)
          {
            int i30 = i17 + -1;
            i19 = i18;
            i17 = i30;
            break label274;
            label502: int i31 = i4 + 1;
            i18 = i17 + -1;
            swap(paramArrayOfByte, i4, i17);
            i17 = i19;
            i4 = i31;
            break;
          }
          label541: i = k;
        }
        i19 = i17;
        i17 = i18;
      }
    }
  }

  private static void sort1(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          int n = paramArrayOfChar[m];
          int i1 = paramArrayOfChar[k];
          if (n > i1);
        }
        else
        {
          i += 1;
          break;
        }
        int i2 = k - 1;
        swap(paramArrayOfChar, k, i2);
        k += -1;
      }
    }
    int i3 = paramInt2 >> 1;
    int k = paramInt1 + i3;
    int i4;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i4 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i5 = paramInt2 / 8;
        int i6 = i + i5;
        int i7 = i5 * 2 + i;
        i = med3(paramArrayOfChar, i, i6, i7);
        int i8 = k - i5;
        int i9 = k + i5;
        k = med3(paramArrayOfChar, i8, k, i9);
        int i10 = i5 * 2;
        int i11 = i4 - i10;
        int i12 = i4 - i5;
        i4 = med3(paramArrayOfChar, i11, i12, i4);
      }
    }
    for (int i = med3(paramArrayOfChar, i, k, i4); ; i = k)
    {
      int i13 = paramArrayOfChar[i];
      int i14 = paramInt1;
      int i15 = i14;
      int i16 = paramInt1 + paramInt2 - 1;
      int i17 = i16;
      int i18 = i16;
      i4 = i15;
      k = i14;
      int i19;
      if (i4 <= i18)
        if (paramArrayOfChar[i4] > i13)
        {
          i19 = i17;
          i17 = i18;
        }
      while (true)
      {
        label274: if ((i17 < i4) || (paramArrayOfChar[i17] < i13))
        {
          if (i4 <= i17)
            break label502;
          paramInt2 += paramInt1;
          int i20 = k - paramInt1;
          int i21 = i4 - k;
          int i22 = Math.min(i20, i21);
          int i23 = i4 - i22;
          vecswap(paramArrayOfChar, paramInt1, i23, i22);
          int i24 = i19 - i17;
          int i25 = paramInt2 - i19 - 1;
          int i26 = Math.min(i24, i25);
          int i27 = paramInt2 - i26;
          vecswap(paramArrayOfChar, i4, i27, i26);
          i = i4 - k;
          if (i > 1)
            sort1(paramArrayOfChar, paramInt1, i);
          paramInt1 = i19 - i17;
          if (paramInt1 <= 1)
            break;
          int i28 = paramInt2 - paramInt1;
          sort1(paramArrayOfChar, i28, paramInt1);
          break;
          if (paramArrayOfChar[i4] != i13)
            break label541;
          i = k + 1;
          swap(paramArrayOfChar, k, i4);
        }
        while (true)
        {
          i4 += 1;
          k = i;
          break;
          int i29;
          if (paramArrayOfChar[i17] == i13)
          {
            i29 = i19 + -1;
            swap(paramArrayOfChar, i17, i19);
          }
          for (i18 = i29; ; i18 = i19)
          {
            int i30 = i17 + -1;
            i19 = i18;
            i17 = i30;
            break label274;
            label502: int i31 = i4 + 1;
            i18 = i17 + -1;
            swap(paramArrayOfChar, i4, i17);
            i17 = i19;
            i4 = i31;
            break;
          }
          label541: i = k;
        }
        i19 = i17;
        i17 = i18;
      }
    }
  }

  private static void sort1(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          long l1 = paramArrayOfDouble[m];
          long l2 = paramArrayOfDouble[k];
          if (l1 > l2);
        }
        else
        {
          i += 1;
          break;
        }
        int n = k - 1;
        swap(paramArrayOfDouble, k, n);
        k += -1;
      }
    }
    int i1 = paramInt2 >> 1;
    int k = paramInt1 + i1;
    int i2;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i2 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i3 = paramInt2 / 8;
        int i4 = i + i3;
        int i5 = i3 * 2 + i;
        i = med3(paramArrayOfDouble, i, i4, i5);
        int i6 = k - i3;
        int i7 = k + i3;
        k = med3(paramArrayOfDouble, i6, k, i7);
        int i8 = i3 * 2;
        int i9 = i2 - i8;
        int i10 = i2 - i3;
        i2 = med3(paramArrayOfDouble, i9, i10, i2);
      }
    }
    for (int i = med3(paramArrayOfDouble, i, k, i2); ; i = k)
    {
      long l3 = paramArrayOfDouble[i];
      int i11 = paramInt1;
      int i12 = i11;
      int i13 = paramInt1 + paramInt2 - 1;
      int i14 = i13;
      int i15 = i13;
      i2 = i12;
      k = i11;
      int i16;
      if (i2 <= i15)
        if (paramArrayOfDouble[i2] > l3)
        {
          i16 = i14;
          i14 = i15;
        }
      while (true)
      {
        label276: if ((i14 < i2) || (paramArrayOfDouble[i14] < l3))
        {
          if (i2 <= i14)
            break label507;
          paramInt2 += paramInt1;
          int i17 = k - paramInt1;
          int i18 = i2 - k;
          int i19 = Math.min(i17, i18);
          int i20 = i2 - i19;
          vecswap(paramArrayOfDouble, paramInt1, i20, i19);
          int i21 = i16 - i14;
          int i22 = paramInt2 - i16 - 1;
          int i23 = Math.min(i21, i22);
          int i24 = paramInt2 - i23;
          vecswap(paramArrayOfDouble, i2, i24, i23);
          i = i2 - k;
          if (i > 1)
            sort1(paramArrayOfDouble, paramInt1, i);
          paramInt1 = i16 - i14;
          if (paramInt1 <= 1)
            break;
          int i25 = paramInt2 - paramInt1;
          sort1(paramArrayOfDouble, i25, paramInt1);
          break;
          if (paramArrayOfDouble[i2] != l3)
            break label546;
          i = k + 1;
          swap(paramArrayOfDouble, k, i2);
        }
        while (true)
        {
          i2 += 1;
          k = i;
          break;
          int i26;
          if (paramArrayOfDouble[i14] == l3)
          {
            i26 = i16 + -1;
            swap(paramArrayOfDouble, i14, i16);
          }
          for (i15 = i26; ; i15 = i16)
          {
            int i27 = i14 + -1;
            i16 = i15;
            i14 = i27;
            break label276;
            label507: int i28 = i2 + 1;
            i15 = i14 + -1;
            swap(paramArrayOfDouble, i2, i14);
            i14 = i16;
            i2 = i28;
            break;
          }
          label546: i = k;
        }
        i16 = i14;
        i14 = i15;
      }
    }
  }

  private static void sort1(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          int n = paramArrayOfFloat[m];
          int i1 = paramArrayOfFloat[k];
          if (n > i1);
        }
        else
        {
          i += 1;
          break;
        }
        int i2 = k - 1;
        swap(paramArrayOfFloat, k, i2);
        k += -1;
      }
    }
    int i3 = paramInt2 >> 1;
    int k = paramInt1 + i3;
    int i4;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i4 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i5 = paramInt2 / 8;
        int i6 = i + i5;
        int i7 = i5 * 2 + i;
        i = med3(paramArrayOfFloat, i, i6, i7);
        int i8 = k - i5;
        int i9 = k + i5;
        k = med3(paramArrayOfFloat, i8, k, i9);
        int i10 = i5 * 2;
        int i11 = i4 - i10;
        int i12 = i4 - i5;
        i4 = med3(paramArrayOfFloat, i11, i12, i4);
      }
    }
    for (int i = med3(paramArrayOfFloat, i, k, i4); ; i = k)
    {
      int i13 = paramArrayOfFloat[i];
      int i14 = paramInt1;
      int i15 = i14;
      int i16 = paramInt1 + paramInt2 - 1;
      int i17 = i16;
      int i18 = i16;
      i4 = i15;
      k = i14;
      int i19;
      if (i4 <= i18)
        if (paramArrayOfFloat[i4] > i13)
        {
          i19 = i17;
          i17 = i18;
        }
      while (true)
      {
        label276: if ((i17 < i4) || (paramArrayOfFloat[i17] < i13))
        {
          if (i4 <= i17)
            break label507;
          paramInt2 += paramInt1;
          int i20 = k - paramInt1;
          int i21 = i4 - k;
          int i22 = Math.min(i20, i21);
          int i23 = i4 - i22;
          vecswap(paramArrayOfFloat, paramInt1, i23, i22);
          int i24 = i19 - i17;
          int i25 = paramInt2 - i19 - 1;
          int i26 = Math.min(i24, i25);
          int i27 = paramInt2 - i26;
          vecswap(paramArrayOfFloat, i4, i27, i26);
          i = i4 - k;
          if (i > 1)
            sort1(paramArrayOfFloat, paramInt1, i);
          paramInt1 = i19 - i17;
          if (paramInt1 <= 1)
            break;
          int i28 = paramInt2 - paramInt1;
          sort1(paramArrayOfFloat, i28, paramInt1);
          break;
          if (paramArrayOfFloat[i4] != i13)
            break label546;
          i = k + 1;
          swap(paramArrayOfFloat, k, i4);
        }
        while (true)
        {
          i4 += 1;
          k = i;
          break;
          int i29;
          if (paramArrayOfFloat[i17] == i13)
          {
            i29 = i19 + -1;
            swap(paramArrayOfFloat, i17, i19);
          }
          for (i18 = i29; ; i18 = i19)
          {
            int i30 = i17 + -1;
            i19 = i18;
            i17 = i30;
            break label276;
            label507: int i31 = i4 + 1;
            i18 = i17 + -1;
            swap(paramArrayOfFloat, i4, i17);
            i17 = i19;
            i4 = i31;
            break;
          }
          label546: i = k;
        }
        i19 = i17;
        i17 = i18;
      }
    }
  }

  private static void sort1(int[] paramArrayOfInt, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          int n = paramArrayOfInt[m];
          int i1 = paramArrayOfInt[k];
          if (n > i1);
        }
        else
        {
          i += 1;
          break;
        }
        int i2 = k - 1;
        swap(paramArrayOfInt, k, i2);
        k += -1;
      }
    }
    int i3 = paramInt2 >> 1;
    int k = paramInt1 + i3;
    int i4;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i4 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i5 = paramInt2 / 8;
        int i6 = i + i5;
        int i7 = i5 * 2 + i;
        i = med3(paramArrayOfInt, i, i6, i7);
        int i8 = k - i5;
        int i9 = k + i5;
        k = med3(paramArrayOfInt, i8, k, i9);
        int i10 = i5 * 2;
        int i11 = i4 - i10;
        int i12 = i4 - i5;
        i4 = med3(paramArrayOfInt, i11, i12, i4);
      }
    }
    for (int i = med3(paramArrayOfInt, i, k, i4); ; i = k)
    {
      int i13 = paramArrayOfInt[i];
      int i14 = paramInt1;
      int i15 = i14;
      int i16 = paramInt1 + paramInt2 - 1;
      int i17 = i16;
      int i18 = i16;
      i4 = i15;
      k = i14;
      int i19;
      if (i4 <= i18)
        if (paramArrayOfInt[i4] > i13)
        {
          i19 = i17;
          i17 = i18;
        }
      while (true)
      {
        label274: if ((i17 < i4) || (paramArrayOfInt[i17] < i13))
        {
          if (i4 <= i17)
            break label502;
          paramInt2 += paramInt1;
          int i20 = k - paramInt1;
          int i21 = i4 - k;
          int i22 = Math.min(i20, i21);
          int i23 = i4 - i22;
          vecswap(paramArrayOfInt, paramInt1, i23, i22);
          int i24 = i19 - i17;
          int i25 = paramInt2 - i19 - 1;
          int i26 = Math.min(i24, i25);
          int i27 = paramInt2 - i26;
          vecswap(paramArrayOfInt, i4, i27, i26);
          i = i4 - k;
          if (i > 1)
            sort1(paramArrayOfInt, paramInt1, i);
          paramInt1 = i19 - i17;
          if (paramInt1 <= 1)
            break;
          int i28 = paramInt2 - paramInt1;
          sort1(paramArrayOfInt, i28, paramInt1);
          break;
          if (paramArrayOfInt[i4] != i13)
            break label541;
          i = k + 1;
          swap(paramArrayOfInt, k, i4);
        }
        while (true)
        {
          i4 += 1;
          k = i;
          break;
          int i29;
          if (paramArrayOfInt[i17] == i13)
          {
            i29 = i19 + -1;
            swap(paramArrayOfInt, i17, i19);
          }
          for (i18 = i29; ; i18 = i19)
          {
            int i30 = i17 + -1;
            i19 = i18;
            i17 = i30;
            break label274;
            label502: int i31 = i4 + 1;
            i18 = i17 + -1;
            swap(paramArrayOfInt, i4, i17);
            i17 = i19;
            i4 = i31;
            break;
          }
          label541: i = k;
        }
        i19 = i17;
        i17 = i18;
      }
    }
  }

  private static void sort1(long[] paramArrayOfLong, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          long l1 = paramArrayOfLong[m];
          long l2 = paramArrayOfLong[k];
          if (l1 > l2);
        }
        else
        {
          i += 1;
          break;
        }
        int n = k - 1;
        swap(paramArrayOfLong, k, n);
        k += -1;
      }
    }
    int i1 = paramInt2 >> 1;
    int k = paramInt1 + i1;
    int i2;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i2 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i3 = paramInt2 / 8;
        int i4 = i + i3;
        int i5 = i3 * 2 + i;
        i = med3(paramArrayOfLong, i, i4, i5);
        int i6 = k - i3;
        int i7 = k + i3;
        k = med3(paramArrayOfLong, i6, k, i7);
        int i8 = i3 * 2;
        int i9 = i2 - i8;
        int i10 = i2 - i3;
        i2 = med3(paramArrayOfLong, i9, i10, i2);
      }
    }
    for (int i = med3(paramArrayOfLong, i, k, i2); ; i = k)
    {
      long l3 = paramArrayOfLong[i];
      int i11 = paramInt1;
      int i12 = i11;
      int i13 = paramInt1 + paramInt2 - 1;
      int i14 = i13;
      int i15 = i13;
      i2 = i12;
      k = i11;
      int i16;
      if (i2 <= i15)
        if (paramArrayOfLong[i2] > l3)
        {
          i16 = i14;
          i14 = i15;
        }
      while (true)
      {
        label276: if ((i14 < i2) || (paramArrayOfLong[i14] < l3))
        {
          if (i2 <= i14)
            break label507;
          paramInt2 += paramInt1;
          int i17 = k - paramInt1;
          int i18 = i2 - k;
          int i19 = Math.min(i17, i18);
          int i20 = i2 - i19;
          vecswap(paramArrayOfLong, paramInt1, i20, i19);
          int i21 = i16 - i14;
          int i22 = paramInt2 - i16 - 1;
          int i23 = Math.min(i21, i22);
          int i24 = paramInt2 - i23;
          vecswap(paramArrayOfLong, i2, i24, i23);
          i = i2 - k;
          if (i > 1)
            sort1(paramArrayOfLong, paramInt1, i);
          paramInt1 = i16 - i14;
          if (paramInt1 <= 1)
            break;
          int i25 = paramInt2 - paramInt1;
          sort1(paramArrayOfLong, i25, paramInt1);
          break;
          if (paramArrayOfLong[i2] != l3)
            break label546;
          i = k + 1;
          swap(paramArrayOfLong, k, i2);
        }
        while (true)
        {
          i2 += 1;
          k = i;
          break;
          int i26;
          if (paramArrayOfLong[i14] == l3)
          {
            i26 = i16 + -1;
            swap(paramArrayOfLong, i14, i16);
          }
          for (i15 = i26; ; i15 = i16)
          {
            int i27 = i14 + -1;
            i16 = i15;
            i14 = i27;
            break label276;
            label507: int i28 = i2 + 1;
            i15 = i14 + -1;
            swap(paramArrayOfLong, i2, i14);
            i14 = i16;
            i2 = i28;
            break;
          }
          label546: i = k;
        }
        i16 = i14;
        i14 = i15;
      }
    }
  }

  private static void sort1(short[] paramArrayOfShort, int paramInt1, int paramInt2)
  {
    if (paramInt2 < 7)
    {
      i = paramInt1;
      int j = paramInt2 + paramInt1;
      if (i >= j)
        return;
      k = i;
      while (true)
      {
        if (k > paramInt1)
        {
          int m = k - 1;
          int n = paramArrayOfShort[m];
          int i1 = paramArrayOfShort[k];
          if (n > i1);
        }
        else
        {
          i += 1;
          break;
        }
        int i2 = k - 1;
        swap(paramArrayOfShort, k, i2);
        k += -1;
      }
    }
    int i3 = paramInt2 >> 1;
    int k = paramInt1 + i3;
    int i4;
    if (paramInt2 > 7)
    {
      i = paramInt1;
      i4 = paramInt1 + paramInt2 - 1;
      if (paramInt2 > 40)
      {
        int i5 = paramInt2 / 8;
        int i6 = i + i5;
        int i7 = i5 * 2 + i;
        i = med3(paramArrayOfShort, i, i6, i7);
        int i8 = k - i5;
        int i9 = k + i5;
        k = med3(paramArrayOfShort, i8, k, i9);
        int i10 = i5 * 2;
        int i11 = i4 - i10;
        int i12 = i4 - i5;
        i4 = med3(paramArrayOfShort, i11, i12, i4);
      }
    }
    for (int i = med3(paramArrayOfShort, i, k, i4); ; i = k)
    {
      int i13 = paramArrayOfShort[i];
      int i14 = paramInt1;
      int i15 = i14;
      int i16 = paramInt1 + paramInt2 - 1;
      int i17 = i16;
      int i18 = i16;
      i4 = i15;
      k = i14;
      int i19;
      if (i4 <= i18)
        if (paramArrayOfShort[i4] > i13)
        {
          i19 = i17;
          i17 = i18;
        }
      while (true)
      {
        label274: if ((i17 < i4) || (paramArrayOfShort[i17] < i13))
        {
          if (i4 <= i17)
            break label502;
          paramInt2 += paramInt1;
          int i20 = k - paramInt1;
          int i21 = i4 - k;
          int i22 = Math.min(i20, i21);
          int i23 = i4 - i22;
          vecswap(paramArrayOfShort, paramInt1, i23, i22);
          int i24 = i19 - i17;
          int i25 = paramInt2 - i19 - 1;
          int i26 = Math.min(i24, i25);
          int i27 = paramInt2 - i26;
          vecswap(paramArrayOfShort, i4, i27, i26);
          i = i4 - k;
          if (i > 1)
            sort1(paramArrayOfShort, paramInt1, i);
          paramInt1 = i19 - i17;
          if (paramInt1 <= 1)
            break;
          int i28 = paramInt2 - paramInt1;
          sort1(paramArrayOfShort, i28, paramInt1);
          break;
          if (paramArrayOfShort[i4] != i13)
            break label541;
          i = k + 1;
          swap(paramArrayOfShort, k, i4);
        }
        while (true)
        {
          i4 += 1;
          k = i;
          break;
          int i29;
          if (paramArrayOfShort[i17] == i13)
          {
            i29 = i19 + -1;
            swap(paramArrayOfShort, i17, i19);
          }
          for (i18 = i29; ; i18 = i19)
          {
            int i30 = i17 + -1;
            i19 = i18;
            i17 = i30;
            break label274;
            label502: int i31 = i4 + 1;
            i18 = i17 + -1;
            swap(paramArrayOfShort, i4, i17);
            i17 = i19;
            i4 = i31;
            break;
          }
          label541: i = k;
        }
        i19 = i17;
        i17 = i18;
      }
    }
  }

  private static void sort2(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    long l1 = Double.doubleToLongBits(-0.0D);
    int i = paramInt1;
    int j = paramInt2;
    paramInt2 = i;
    int k = j;
    if (paramInt2 >= k)
    {
      int m = k - paramInt1;
      sort1(paramArrayOfDouble, paramInt1, m);
      if (0 != 0)
      {
        paramInt1 = binarySearch0(paramArrayOfDouble, paramInt1, k, 0.0D);
        do
          paramInt1 += -1;
        while ((paramInt1 >= 0) && (paramArrayOfDouble[paramInt1] == 0.0D));
        paramInt2 = 0;
      }
    }
    while (true)
    {
      if (paramInt2 >= 0)
      {
        return;
        long l2 = paramArrayOfDouble[paramInt2];
        long l3 = paramArrayOfDouble[paramInt2];
        if (l2 != l3)
        {
          long l4 = paramArrayOfDouble[paramInt2];
          k += -1;
          long l5 = paramArrayOfDouble[k];
          paramArrayOfDouble[paramInt2] = l5;
          paramArrayOfDouble[k] = l4;
          break;
        }
        if ((paramArrayOfDouble[paramInt2] == 0.0D) && (Double.doubleToLongBits(paramArrayOfDouble[paramInt2]) == l1))
        {
          paramArrayOfDouble[paramInt2] = 0L;
          int n = 0 + 1;
        }
        paramInt2 += 1;
        break;
      }
      paramInt1 += 1;
      paramArrayOfDouble[paramInt1] = -9223372036854775808L;
      paramInt2 += 1;
    }
  }

  private static void sort2(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    int i = Float.floatToIntBits(-0.0F);
    int j = paramInt1;
    int k = paramInt2;
    int n;
    int i1;
    if (j >= k)
    {
      int m = k - paramInt1;
      sort1(paramArrayOfFloat, paramInt1, m);
      if (0 != 0)
      {
        n = binarySearch0(paramArrayOfFloat, paramInt1, k, 0.0F);
        do
          n += -1;
        while ((n >= 0) && (paramArrayOfFloat[n] == 0.0F));
        i1 = 0;
      }
    }
    while (true)
    {
      if (i1 >= 0)
      {
        return;
        int i2 = paramArrayOfFloat[j];
        int i3 = paramArrayOfFloat[j];
        if (i2 != i3)
        {
          int i4 = paramArrayOfFloat[j];
          k += -1;
          int i5 = paramArrayOfFloat[k];
          paramArrayOfFloat[j] = i5;
          paramArrayOfFloat[k] = i4;
          break;
        }
        if ((paramArrayOfFloat[j] == 0.0F) && (Float.floatToIntBits(paramArrayOfFloat[j]) == i))
        {
          paramArrayOfFloat[j] = 0;
          int i6 = 0 + 1;
        }
        j += 1;
        break;
      }
      n += 1;
      paramArrayOfFloat[n] = -2147483648;
      i1 += 1;
    }
  }

  private static void swap(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    int i = paramArrayOfByte[paramInt1];
    int j = paramArrayOfByte[paramInt2];
    paramArrayOfByte[paramInt1] = j;
    paramArrayOfByte[paramInt2] = i;
  }

  private static void swap(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    int i = paramArrayOfChar[paramInt1];
    int j = paramArrayOfChar[paramInt2];
    paramArrayOfChar[paramInt1] = j;
    paramArrayOfChar[paramInt2] = i;
  }

  private static void swap(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    long l1 = paramArrayOfDouble[paramInt1];
    long l2 = paramArrayOfDouble[paramInt2];
    paramArrayOfDouble[paramInt1] = l2;
    paramArrayOfDouble[paramInt2] = l1;
  }

  private static void swap(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    int i = paramArrayOfFloat[paramInt1];
    int j = paramArrayOfFloat[paramInt2];
    paramArrayOfFloat[paramInt1] = j;
    paramArrayOfFloat[paramInt2] = i;
  }

  private static void swap(int[] paramArrayOfInt, int paramInt1, int paramInt2)
  {
    int i = paramArrayOfInt[paramInt1];
    int j = paramArrayOfInt[paramInt2];
    paramArrayOfInt[paramInt1] = j;
    paramArrayOfInt[paramInt2] = i;
  }

  private static void swap(long[] paramArrayOfLong, int paramInt1, int paramInt2)
  {
    long l1 = paramArrayOfLong[paramInt1];
    long l2 = paramArrayOfLong[paramInt2];
    paramArrayOfLong[paramInt1] = l2;
    paramArrayOfLong[paramInt2] = l1;
  }

  private static void swap(Object[] paramArrayOfObject, int paramInt1, int paramInt2)
  {
    Object localObject1 = paramArrayOfObject[paramInt1];
    Object localObject2 = paramArrayOfObject[paramInt2];
    paramArrayOfObject[paramInt1] = localObject2;
    paramArrayOfObject[paramInt2] = localObject1;
  }

  private static void swap(short[] paramArrayOfShort, int paramInt1, int paramInt2)
  {
    int i = paramArrayOfShort[paramInt1];
    int j = paramArrayOfShort[paramInt2];
    paramArrayOfShort[paramInt1] = j;
    paramArrayOfShort[paramInt2] = i;
  }

  public static String toString(byte[] paramArrayOfByte)
  {
    if (paramArrayOfByte == null);
    int i;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      i = paramArrayOfByte.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      int k = paramArrayOfByte[j];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(k);
      if (j == i)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  public static String toString(char[] paramArrayOfChar)
  {
    if (paramArrayOfChar == null);
    int i;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      i = paramArrayOfChar.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      char c = paramArrayOfChar[j];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(c);
      if (j == i)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  public static String toString(double[] paramArrayOfDouble)
  {
    if (paramArrayOfDouble == null);
    long l1;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      l1 = paramArrayOfDouble.length - 1;
      if (l1 != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    long l2 = 0;
    while (true)
    {
      long l3 = paramArrayOfDouble[l2];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(l3);
      if (l2 == l1)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      int i;
      l2 += 1;
    }
  }

  public static String toString(float[] paramArrayOfFloat)
  {
    if (paramArrayOfFloat == null);
    int i;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      i = paramArrayOfFloat.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      int k = paramArrayOfFloat[j];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(k);
      if (j == i)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  public static String toString(int[] paramArrayOfInt)
  {
    if (paramArrayOfInt == null);
    int i;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      i = paramArrayOfInt.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      int k = paramArrayOfInt[j];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(k);
      if (j == i)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  public static String toString(long[] paramArrayOfLong)
  {
    if (paramArrayOfLong == null);
    long l1;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      l1 = paramArrayOfLong.length - 1;
      if (l1 != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    long l2 = 0;
    while (true)
    {
      long l3 = paramArrayOfLong[l2];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(l3);
      if (l2 == l1)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      int i;
      l2 += 1;
    }
  }

  public static String toString(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null);
    int i;
    for (String str1 = "null"; ; str1 = "[]")
    {
      return str1;
      i = paramArrayOfObject.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      String str2 = String.valueOf(paramArrayOfObject[j]);
      StringBuilder localStringBuilder3 = localStringBuilder1.append(str2);
      if (j == i)
      {
        str1 = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  public static String toString(short[] paramArrayOfShort)
  {
    if (paramArrayOfShort == null);
    int i;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      i = paramArrayOfShort.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      int k = paramArrayOfShort[j];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(k);
      if (j == i)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  public static String toString(boolean[] paramArrayOfBoolean)
  {
    if (paramArrayOfBoolean == null);
    int i;
    for (String str = "null"; ; str = "[]")
    {
      return str;
      i = paramArrayOfBoolean.length - 1;
      if (i != -1)
        break;
    }
    StringBuilder localStringBuilder1 = new StringBuilder();
    StringBuilder localStringBuilder2 = localStringBuilder1.append(91);
    int j = 0;
    while (true)
    {
      int k = paramArrayOfBoolean[j];
      StringBuilder localStringBuilder3 = localStringBuilder1.append(k);
      if (j == i)
      {
        str = 93;
        break;
      }
      StringBuilder localStringBuilder4 = localStringBuilder1.append(", ");
      j += 1;
    }
  }

  private static void vecswap(byte[] paramArrayOfByte, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfByte, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  private static void vecswap(char[] paramArrayOfChar, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfChar, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  private static void vecswap(double[] paramArrayOfDouble, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfDouble, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  private static void vecswap(float[] paramArrayOfFloat, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfFloat, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  private static void vecswap(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfInt, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  private static void vecswap(long[] paramArrayOfLong, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfLong, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  private static void vecswap(short[] paramArrayOfShort, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = 0;
    while (true)
    {
      if (i >= paramInt3)
        return;
      swap(paramArrayOfShort, paramInt1, paramInt2);
      i += 1;
      paramInt1 += 1;
      paramInt2 += 1;
    }
  }

  class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, Serializable
  {
    private static final long serialVersionUID = -2764017481108945198L;

    ArrayList()
    {
      if (Arrays.this == null)
        throw new NullPointerException();
    }

    public boolean contains(Object paramObject)
    {
      if (indexOf(paramObject) != -1);
      for (int i = 1; ; i = 0)
        return i;
    }

    public E get(int paramInt)
    {
      return Arrays.this[paramInt];
    }

    public int indexOf(Object paramObject)
    {
      int k;
      if (paramObject == null)
      {
        i = 0;
        while (true)
        {
          int j = Arrays.this.length;
          if (i >= j);
          for (k = -1; ; k = i)
          {
            label21: return k;
            if (Arrays.this[i] != 0)
              break;
          }
          i += 1;
        }
      }
      int i = 0;
      while (true)
      {
        int m = Arrays.this.length;
        if (i >= m)
          break;
        Object localObject = Arrays.this[i];
        if (paramObject.equals(localObject))
        {
          k = i;
          break label21;
        }
        i += 1;
      }
    }

    public E set(int paramInt, E paramE)
    {
      Object localObject = Arrays.this[paramInt];
      Arrays.this[paramInt] = paramE;
      return localObject;
    }

    public int size()
    {
      return Arrays.this.length;
    }

    public Object[] toArray()
    {
      return (Object[])Arrays.this.clone();
    }

    public <T> T[] toArray(T[] paramArrayOfT)
    {
      int i = size();
      Object[] arrayOfObject;
      Class localClass;
      if (paramArrayOfT.length < i)
      {
        arrayOfObject = Arrays.this;
        localClass = paramArrayOfT.getClass();
      }
      for (Object localObject = Arrays.copyOf(arrayOfObject, i, localClass); ; localObject = paramArrayOfT)
      {
        return localObject;
        System.arraycopy(Arrays.this, 0, paramArrayOfT, 0, i);
        if (paramArrayOfT.length <= i)
          continue;
        paramArrayOfT[i] = 0;
      }
    }
  }
}

/* Location:           D:\Program Files\eclipse\apktool-r01-3\新浪微博\classes.dex.dex2jar.jar
 * Qualified Name:     sudroid.java.util.Arrays
 * JD-Core Version:    0.6.0
 */